package fr.miage.orleans.aar.ejb;

import fr.miage.orleans.aar.modele.Arbitre;
import fr.miage.orleans.aar.modele.But;
import fr.miage.orleans.aar.modele.ButTirAuBut;
import fr.miage.orleans.aar.modele.Equipe;
import fr.miage.orleans.aar.modele.EquipeTournoi;
import fr.miage.orleans.aar.modele.Joueur;
import fr.miage.orleans.aar.modele.MatchTour;
import fr.miage.orleans.aar.modele.PosteJoueur;
import fr.miage.orleans.aar.modele.Tournoi;
import fr.miage.orleans.aar.modele.valueobject.ValueObjectMatch;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

/**
 *
 * @author Steve Cancès <steve.cances@gmail.com>
 */
@Stateless
@LocalBean
public class FacadeGettersBean implements FacadeGettersLocal {

    @PersistenceContext(unitName = FacadeUtils.PERSISTENCE_CONTEXT_UNIT_NAME)
    private EntityManager entityManager;

    @Override
    public Collection<PosteJoueur> getPostesJoueurs() {
	Collection<PosteJoueur> postes = this.entityManager.createQuery("From PosteJoueur pj").getResultList();
	return postes;
    }

    @Override
    public Collection<Joueur> getAllJoueurs() {
	Collection<Joueur> joueurs = this.entityManager.createQuery("From Joueur j").getResultList();
	return joueurs;
    }

    @Override
    public Collection<Tournoi> getAllTournois() {
	Collection<Tournoi> tournois = this.entityManager.createQuery("From Tournoi t").getResultList();
	return tournois;
    }

    @Override
    public Collection<Equipe> getAllEquipes() {
	Collection<Equipe> equipes = this.entityManager.createQuery("From Equipe e").getResultList();
	return equipes;
    }

    private Collection<MatchTour> getAllMatchTours() {
	Collection<MatchTour> matchs = this.entityManager.createQuery("From MatchTour m").getResultList();
	return matchs;	
    }

    @Override
    public Tournoi getTournoiById(int id) {
	Tournoi tournoi = null;
	Query query = entityManager.createQuery("From Tournoi t where t.tournoiId=:id");
	query.setParameter("id", id);
	try {
	    tournoi = (Tournoi) query.getSingleResult();
	} catch (Exception ex) {

	}
	return tournoi;
    }

    @Override
    public Tournoi getTournoiDetailById(int id) {
	Tournoi tournoi = this.getTournoiById(id);
	if (tournoi != null) {
	    Collection<EquipeTournoi> equipeTournois = tournoi.getEquipesTournoi();
	    for (EquipeTournoi equipeTournoi : equipeTournois) {
		Collection<Joueur> joueurs = equipeTournoi.getEquipe().getJoueurs();
		for (Joueur joueur : joueurs) {
		    joueur.getNom();
		}
	    }

	    Collection<MatchTour> matchs = tournoi.getMatchs();
	    for (MatchTour match : matchs) {
		match.getMatchTourId();
	    }

	}
	return tournoi;
    }

    @Override
    public Equipe getEquipeById(int equipeId) {
	Equipe equipe = null;
	Query query = entityManager.createQuery("From Equipe e where e.equipeId=:id");
	query.setParameter("id", equipeId);
	try {
	    equipe = (Equipe) query.getSingleResult();
	} catch (Exception ex) {

	}
	return equipe;
    }

    @Override
    public EquipeTournoi getEquipeTournoiById(int tournoiId, int equipeId) {
	Tournoi tournoi = this.getTournoiById(tournoiId);
	Collection<EquipeTournoi> equipeTournois = tournoi.getEquipesTournoi();
	for (EquipeTournoi equipeTournoi : equipeTournois) {
	    if (equipeTournoi.getEquipe().getEquipeId() == equipeId) {
		return equipeTournoi;
	    }
	}
	return null;
    }

    /*
    @Override
    public MatchTour getMatchTourById(int matchId) {
	MatchTour matchTour = null;
	Query query = entityManager.createQuery("From MatchTour m where m.matchTourId=:ident");
	query.setParameter("ident", matchId);
	try {
	    matchTour = (MatchTour) query.getSingleResult();
	} catch (Exception ex) {
	    throw new RuntimeException(ex);
	}
	return matchTour;
    }
    */
    
    /**
     * PANSEMENT
     * @param matchId
     * @return 
     */
    @Override
    public MatchTour getMatchTourById(int matchId) {
	MatchTour matchTour = null;
	Collection<MatchTour> allMatchTours = this.getAllMatchTours();
	for(MatchTour mt : allMatchTours) {
	    if(mt.getMatchTourId() == matchId) {
		matchTour = mt;
	    }
	}
	return matchTour;
    }

    @Override
    public MatchTour getMatchTourFrereById(int matchId) {
	MatchTour matchTour = this.getMatchTourById(matchId);
	MatchTour matchTourFrere = null;
	if (matchTour != null) {
	    //ListMatch
	    ValueObjectMatch voMatch = new ValueObjectMatch(matchTour);
	    List<Integer> listeNumMatch = new ArrayList<>();
	    int _num = 1;
	    int nbMatch = matchTour.getTournoi().getEquipesTournoi().size();
	    int rang=  voMatch.getRangMatch();
	    int inc = (int) Math.pow(2, rang-1);
	    for(int j = 0 ; j < rang ; ++j)
	    {
		nbMatch = nbMatch /2;
	    }
	    for(int  i = 0 ; i <nbMatch ; i++)
	    {
		listeNumMatch.add(_num);
		_num+=inc;
	    }
	    int numeroMatchFrere = 0;
	    System.out.println("rang : "+rang);
	    if(rang == 4) {
		System.out.println("rang !!!!!!!!!!!!!!! : "+rang);
	    }
	    System.out.println("listeNumMatch.size() : "+listeNumMatch.size());
	    System.out.println("matchTour.getNumeroMatch() : "+matchTour.getNumeroMatch());
	    for(int i = 0 ; i < listeNumMatch.size() ; ++i)
	    {
		System.out.println("listeNumMatch.get(i) : "+listeNumMatch.get(i));
		if(listeNumMatch.get(i) == matchTour.getNumeroMatch())
		{
		    if(i%2 == 0)
		    {
			numeroMatchFrere = listeNumMatch.get(i+1);
		    }
		    else
		    {
			numeroMatchFrere = listeNumMatch.get(i-1);
		    }
		}
	    }
	    System.out.println("Numéro du match frere : " + numeroMatchFrere);
	   
	    int rangMatch = voMatch.getRangMatch();
	    Tournoi tournoi = matchTour.getTournoi();
	    Collection<MatchTour> allMatchs = tournoi.getMatchs();//this.getAllMatchTours();
	    for (MatchTour matchCourant : allMatchs) {
		ValueObjectMatch voMatchCourant = new ValueObjectMatch(matchCourant);
		if (voMatchCourant.getRangMatch() == rangMatch && voMatchCourant.getNumeroMatch() == numeroMatchFrere) {
		    System.out.println("Trouvé1 : " + voMatchCourant.getRangMatch());
		    System.out.println("Trouvé2 : " + voMatchCourant.getNumeroMatch());
		    matchTourFrere = matchCourant;
		    break;
		}
	    }
	    System.out.println("Le frere de ("+rang+ " / " + voMatch.getNumeroMatch() + ") est (" + matchTourFrere.getMatchTourId() + ")");
	}
	return matchTourFrere;
    }

    @Override
    public PosteJoueur getPosteJoueurById(int PosteId) {
	PosteJoueur posteJoueur = null;
	try {
	    //matchTour = entityManager.find(MatchTour.class, matchId);
	    Query query = entityManager.createQuery("From PosteJoueur p where p.posteJoueurId=:id");
	    query.setParameter("id", PosteId);
	    posteJoueur = (PosteJoueur) query.getSingleResult();
	} catch (Exception ex) {
	}
	return posteJoueur;
    }

    @Override
    public Joueur getJoueurById(int idJoueur) {
	Joueur joueur = null;
	Query query = entityManager.createQuery("From Joueur j where j.personneId=:id");
	query.setParameter("id", idJoueur);
	try {
	    joueur = (Joueur) query.getSingleResult();
	} catch (Exception ex) {

	}
	return joueur;
    }

    @Override
    public Collection<Joueur> getJoueursEquipe(int equipeId) {
	Equipe e = this.getEquipeById(equipeId);
	Collection<Joueur> returnvalue = new ArrayList<>();
	for (Joueur aJoueur : e.getJoueurs()) {
	    returnvalue.add(aJoueur.getValueObject());
	}
	return returnvalue;
    }

    @Override
    public Collection<Joueur> getJoueursSansEquipes() {
	Collection<Joueur> returnvalue = null;
	Query query = entityManager.createQuery("From Joueur j where equipe.equipeId IS NULL");
	try {
	    returnvalue = query.getResultList();
	} catch (Exception ex) {
	    throw new RuntimeException(ex);
	}
	return returnvalue;
    }

    @Override
    public Collection<Equipe> getEquipesNonInscrites(int tournoiId) {
        Collection<Equipe> returnvalue;
        Query query = entityManager
                .createQuery("From Equipe e where e.equipeId NOT IN (SELECT equipe.equipeId from EquipeTournoi e2 WHERE tournoi.tournoiId=:idTournoi) ");
        query.setParameter("idTournoi", tournoiId);
        try {
            returnvalue = query.getResultList();
            List<Equipe> correctReturnValue= new ArrayList<>();
            for(Equipe e : returnvalue)
            {
            	if(e.getJoueurs().size() >= 11)
            	{
            		correctReturnValue.add(e);
            	}
            }
            returnvalue = correctReturnValue;
        } catch (Exception ex) {
            returnvalue = new ArrayList<>();
        }
        return returnvalue;
    }

    @Override
    public Arbitre getArbitreById(int idArbitre) {
	Arbitre arbitre = null;
	Query query = entityManager.createQuery("From Arbitre a where a.personneId=:id");
	query.setParameter("id", idArbitre);
	try {
	    arbitre = (Arbitre) query.getSingleResult();
	} catch (Exception ex) {

	}
	return arbitre;
    }

}
